package com.swp.oa.util;

import com.swp.oa.comomn.Option;


public class LibraryHelper {
	
	private static String fileRepository = Option.getFilePath(); // 本地文件仓目录
	private static String svnRepositoryUrl = Option.getSvnPath(); // svn仓库url
	private static String libraryUrl = Option.getLibraryUrl();
	
	// TODO(lvly):
	// 遗留问题：临时TaskId可能与ComputationID重复
	private static long tempTaskId = 66666; // 分配临时TaskId，降低重复概率
	
	/**
	 * 元素URL解析成相对路径
	 * @param elemUrl	URL
	 * @return	相对路径
	 */
	public static String resolveLibraryUrlToRelPath(String elemUrl) {
		
		// 相对路径相对文件仓根目录，不包含根目录
		// http://localhost:8080/Library/ -> ""
		// http://localhost:8080/Library/cots -> "cots"
		//替换“\”
		String url = elemUrl.replace('\\',  '/');
		
		final String trim = "\\/";
		//去掉路径末尾的“\/”
		String libraryUrl = StringHelper.trimEnd(Option.getLibraryUrl(), trim);
		int index = url.indexOf(libraryUrl);
		if(index == -1){
			return url;
		}
		
		String relPath = url.substring(libraryUrl.length());
		return StringHelper.trimStart(relPath, trim);
	}

	/**
	 * 元素URL解析成绝对路径
	 * @param elemUrl	URL
	 * @return	绝对路径
	 */
	public static String resolveLibraryUrlToAbsPath(String elemUrl) {
		//替换“\”
		String url = elemUrl.replace('\\', '/');
		
		String relPath = resolveLibraryUrlToRelPath(url);
		
		final String trim = "\\/";
		//去掉路径末尾的“\/”
		String absPath = StringHelper.trimEnd(fileRepository, trim);
		
		if(!relPath.isEmpty()){ //如果路径不为空
			
			absPath = absPath + "/" + StringHelper.trimStart(relPath, trim);
		}
		
		return absPath;
	}
	
	/**
	 * 解析绝对路径为相对路径
	 * @param absPath
	 * @return
	 */
	public static String resolveAbsLibraryPathToRel(String absPath){
		//替换“\”
		String path = absPath.replace('\\', '/');
		
		final String trim = "\\/";
		assert(path.startsWith(fileRepository)); 
		assert(path.length() >= fileRepository.length());
		
		//获取相对路径
		String rel = absPath.substring(fileRepository.length());
		
		//去掉路径开头的“\/”
		return StringHelper.trimStart(rel, trim);
	}
	
	/**
	 * 解析相对路径为url
	 * @param rel
	 * @return
	 */
	public static String resolveRelPathToLibraryUrl(String rel){
		//替换“\”
		String relative = rel.replace('\\', '/');
		final String trim = "\\/";
		
		//去掉路径末尾的“\/”
		String rootLib = StringHelper.trimEnd(libraryUrl, trim);
		
		//合成url
		return FileHelper.makePath(rootLib, StringHelper.trimStart(relative, trim));
	}
	
	/**
	 * 解析绝对路径为url
	 * @param absPath
	 * @return
	 */
	public static String resolveAbsPathToLibraryUrl(String absPath){
		//解析绝对路径为相对路径
		String rel = resolveAbsLibraryPathToRel(absPath);
		
		//解析相对路径为url
		return resolveRelPathToLibraryUrl(rel);
	}
	
	/**
	 * 解析相对路径为svn路径
	 * @param relDirectory
	 * @return
	 */
	public static String resolveRelPathToSvnUrl(String relDirectory){
		//替换“\”
		String relative = relDirectory.replace('\\', '/');
		
		final String trim = "\\/";
		//合成svn路径
		return FileHelper.makePath(
				StringHelper.trimEnd(svnRepositoryUrl, trim),
				StringHelper.trimStart(relative, trim));
	}
	
	public static String resolveLibraryUrlToSvnUrl(String elemUrl){
		String relDirectory = resolveLibraryUrlToRelPath(elemUrl);
		return resolveRelPathToSvnUrl(relDirectory);
	}
	
	public static String resolveAbsPathToSvnUrl(String absLibraryPath){
		String relLibraryPath = resolveAbsLibraryPathToRel(absLibraryPath);
		return resolveRelPathToSvnUrl(relLibraryPath);
	}
	
    /**
     * 分配缓存目录
     * @param directoryName 目录名字
     * @param create 创建目录
     * @return 目录路径
     */
	public static String makeCacheDirectory(String directoryName, boolean create){
		//生成一个唯一文件夹在缓冲区
		String parent = FileHelper.makePath(Option.getCache(), java.util.UUID.randomUUID().toString());
		
		String cachePath = parent;
		if (!directoryName.isEmpty()) {//不为空
			//合成路径
			cachePath = FileHelper.makePath(parent, directoryName);
		}
		
		if(create){
			//创建文件夹
			FileHelper.createFile(cachePath, true, true);
		}
		
		// 路径中包含'/'时，CotsFile接口读取组件描述文件报错
		// 替换“/”
		return cachePath.replace('/', '\\');
    }
	
	/**
	 * 分配关联目录
	 * @param create 组件名字
	 * @param create 创建目录
	 * @return 关联目录
	 */
	public static String makeAssociteDirectory(String name, boolean create){
		
		//生成一个唯一文件夹在临时文件夹
		String parent = FileHelper.makePath(Option.getTemporary(), java.util.UUID.randomUUID().toString());
		
		String assPath = parent;
		if (!name.isEmpty()) { //不为空
			
			//合成路径
			assPath = FileHelper.makePath(parent, name);
		}
		
		if(create){
			//创建文件夹
			FileHelper.createFile(assPath, true, true);
		}
		
		// 路径中包含'/'时，CotsFile接口读取组件描述文件报错
		// 替换“/”
		return assPath.replace('/', '\\');
	}

	/**
	 * 下载文件到指定路径
	 * @param pathUrl
	 * @param absDes
	 * @return
	 */
	public static boolean downloadFile(String pathUrl, String absDes) {
		//解析url为绝对路径
//		String absSource = LibraryHelper.resolveLibraryUrlToAbsPath(pathUrl);

		// return FileHelper.copyDirectory(absSource, absDes, true);
		try {
//			CompressFile compressFile = CompressFile.getInstance();
			// 解压缩到目录路径
//			compressFile.unzip(absSource, absDes);
		} catch (Exception e) {
			e.printStackTrace();
			return false; // 下载文件失败
		}

		return true;
	}
	
	/**
	 * 下载元素到指定目录，并解压
	 * @param elemAddress 元素在文件仓中的地址（url）
	 * @param absDes 目标目录
	 * @param revision 目标版本
	 * @param latestRevision 元素最新版本
	 * @param deleteZip 删除目标目录中zip文件
	 * @return 下载是否成功
	 */
	public static boolean downloadFile(String elemAddress, String absDes, long revision, String latestRevision, boolean deleteZip){
		
//		// 判断是否是最新版本
//		
//		boolean isLatestRevision = LibraryHelper.isLatestRevision(revision, latestRevision);
//		
//		// 最新版本
//		if (isLatestRevision) {
//			return LibraryHelper.downloadFile(elemAddress, absDes);
//		}
//
//		// 获取历史版本
//		SvnDalWorkingCopy dalSvnWC = new SvnDalWorkingCopy();
//		String svnAbsUrl = LibraryHelper.resolveLibraryUrlToSvnUrl(elemAddress);
//		
//		String svnVersionString  = dalSvnWC.convertToSvnVersion(svnAbsUrl, revision-1);
//		
//		if (svnVersionString.isEmpty()) { //如果为空
//			LibraryHelper.printMessage("获取历史版本文件失败.", true);
//			return false;		 
//		}
//		
//		long revisionExport = dalSvnWC.export(svnAbsUrl, svnVersionString,
//				svnVersionString, absDes, true);
//		
//		revision = Long.parseLong(svnVersionString);
//		assert(revision == revisionExport);
//		if (revision != revisionExport) {
//			LibraryHelper.printMessage("获取历史版本文件失败.", true);
//			return false;
//		}
//		
//		// 导出的.zip文件路径
//		String absSource = FileHelper.makePath(absDes, FileHelper.getLastFileName(elemAddress));
//		
//		try {			
//			CompressFile compressFile = CompressFile.getInstance();
//			compressFile.unzip(absSource, absDes);
//		} catch (Exception e) {
//			e.printStackTrace();
//			return false; // 下载文件失败
//		}
//
//		// 删除.zip文件
//		if (deleteZip) {
//			FileHelper.deleteFile(absSource);
//		}
		
		return true;
	}
	
	public static long dispatchTempTaskId(){
		return ++tempTaskId;
	}
	
	/**
	 * 判断历史版本是否是最新版本，revision = 0时，返回true
	 * @param revision
	 * @param latest
	 * @return
	 */
	public static boolean isLatestRevision(long revision, String latest){
		assert(revision >=0);
		
		long latestLong = Long.parseLong(latest);
		assert(latestLong > 0 && revision < latestLong);
		
		if (revision == 0) {
			return true;
		}
		
		return revision == latestLong;
	}
	
	//打印错误信息
	public static void printMessage(String msg, boolean err){
		String message = msg;
		if (err) {
			message = "Error: " + msg;
		}
		System.out.println(message);
	}

} // end class
